import ast
import logging
from typing import Optional, List, Set

from 程序核心代码.ast节点.节点定义.基础定义.ast节点基础定义 import ast节点基础模型
from 程序核心代码.ast节点.节点定义.基础定义.节点状态管理 import 节点状态类型

logger = logging.getLogger(__name__)

class 循环ast节点基础模型(ast节点基础模型):
    """循环节点类，用于处理for循环控制流"""
    
    def __init__(self, ast节点: ast.For, 节点管理器,
                 节点位置: Optional[List] = None, 上级节点: Optional['ast节点基础模型'] = None):
        super().__init__(ast节点, 所属节点模型管理器, "循环ast节点基础模型", "控制流", 节点位置, True, 上级节点)
        
        # 循环相关属性
        self.目标变量 = None  # 循环变量
        self.迭代对象 = None  # 被迭代的对象
        self.循环主体: Set[ast节点基础模型] = set()
        self.否则主体: Set[ast节点基础模型] = set()
        self.当前迭代索引 = 0
        self.迭代值列表 = []
        
        # 添加接口
        self.添加接口("控制流", "输入", "控制输入")
        self.添加接口("控制流", "输出", "主体输出")
        self.添加接口("控制流", "输出", "否则输出")
        self.添加接口("数据流", "输入", "迭代输入")
        
    def 节点数据解析(self) -> None:
        """解析节点数据"""
        try:
            # 解析目标变量
            self.目标变量 = self.所属节点模型管理器.创建节点(self.ast节点.target)
            if not self.目标变量:
                self.添加错误信息("循环变量创建失败")
                return
                
            # 解析迭代对象
            self.迭代对象 = self.所属节点模型管理器.创建节点(self.ast节点.iter)
            if not self.迭代对象:
                self.添加错误信息("迭代对象创建失败")
                return
                
            # 解析循环主体
            for 语句 in self.ast节点.body:
                节点 = self.所属节点模型管理器.创建节点(语句, 上级节点=self)
                if 节点:
                    self.循环主体.add(节点)
                    
            # 解析else部分
            for 语句 in self.ast节点.orelse:
                节点 = self.所属节点模型管理器.创建节点(语句, 上级节点=self)
                if 节点:
                    self.否则主体.add(节点)
                    
            # 更新节点显示名称
            self.节点标题名称 = f"for循环({self.目标变量})"
            
        except Exception as e:
            logger.error(f"循环节点数据解析失败: {str(e)}")
            self.添加错误信息(f"数据解析失败: {str(e)}")
            
    def 准备迭代(self) -> bool:
        """准备迭代过程"""
        try:
            if not self.迭代对象:
                self.添加错误信息("迭代对象未定义")
                return False
                
            # 获取迭代对象的值
            迭代对象值 = self.迭代对象.获取变量值()
            if 迭代对象值 is None:
                self.添加错误信息("迭代对象值获取失败")
                return False
                
            # 转换为列表以支持迭代
            self.迭代值列表 = list(迭代对象值)
            self.当前迭代索引 = 0
            return True
            
        except Exception as e:
            logger.error(f"迭代准备失败: {str(e)}")
            self.添加错误信息(f"迭代准备失败: {str(e)}")
            return False
            
    def 执行循环(self) -> None:
        """执行循环"""
        try:
            if not self.准备迭代():
                return
                
            # 执行循环
            for 值 in self.迭代值列表:
                # 更新循环变量
                self.目标变量.更新变量值(值)
                
                # 执行循环体
                for 节点 in self.循环主体:
                    节点.执行()
                    
                self.当前迭代索引 += 1
                
            # 执行else部分
            for 节点 in self.否则主体:
                节点.执行()
                
            self.状态管理器.更新状态(节点状态类型.已完成)
            
        except Exception as e:
            logger.error(f"循环执行失败: {str(e)}")
            self.添加错误信息(f"执行失败: {str(e)}")
            
    def 创建独立节点(self) -> None:
        """创建独立的AST节点"""
        self.ast节点 = ast.For(
            target=ast.Name(id='i', ctx=ast.Store()),
            iter=ast.List(elts=[], ctx=ast.Load()),
            body=[ast.Pass()],
            orelse=[]
        )
        
    def __str__(self) -> str:
        """返回循环节点的字符串表示"""
        return f"{self.获取属性("节点名称")}(迭代索引={self.当前迭代索引})" 